/**
 * 工具函数
 * 提供日期格式化、数据验证等通用功能
 */

/**
 * 格式化日期为中文格式
 * @param {string|Date} date - 日期字符串或Date对象
 * @returns {string} 格式化后的日期字符串
 */
function formatDate(date) {
    const d = new Date(date);
    const year = d.getFullYear();
    const month = d.getMonth() + 1;
    const day = d.getDate();
    
    return `${year}年${month}月${day}日`;
}

/**
 * 格式化日期为简短格式
 * @param {string|Date} date - 日期字符串或Date对象
 * @returns {string} 格式化后的日期字符串
 */
function formatDateShort(date) {
    const d = new Date(date);
    const month = d.getMonth() + 1;
    const day = d.getDate();
    
    return `${month}/${day}`;
}

/**
 * 获取当前日期的ISO字符串
 * @returns {string} 当前日期的ISO字符串
 */
function getCurrentDateISO() {
    return new Date().toISOString();
}

/**
 * 计算两个日期之间的天数差
 * @param {string|Date} startDate - 开始日期
 * @param {string|Date} endDate - 结束日期
 * @returns {number} 天数差
 */
function getDaysDifference(startDate, endDate) {
    const start = new Date(startDate);
    const end = new Date(endDate);
    const diffTime = end - start;
    return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
}

/**
 * 验证记忆内容数据
 * @param {Object} memoryData - 记忆内容数据
 * @returns {Object} 验证结果 {valid: boolean, message: string}
 */
function validateMemoryData(memoryData) {
    if (!memoryData) {
        return { valid: false, message: '记忆内容数据不能为空' };
    }
    
    if (!memoryData.groupId) {
        return { valid: false, message: '组ID不能为空' };
    }
    
    if (!memoryData.day || memoryData.day < 1 || memoryData.day > 100) {
        return { valid: false, message: '天数必须在1-100之间' };
    }
    
    if (memoryData.hint && memoryData.hint.length > 200) {
        return { valid: false, message: '记忆提示不能超过200个字符' };
    }
    
    if (memoryData.content && memoryData.content.length > 1000) {
        return { valid: false, message: '记忆内容不能超过1000个字符' };
    }
    
    return { valid: true, message: '验证通过' };
}

/**
 * 验证组数据
 * @param {Object} groupData - 组数据
 * @returns {Object} 验证结果 {valid: boolean, message: string}
 */
function validateGroupData(groupData) {
    if (!groupData) {
        return { valid: false, message: '组数据不能为空' };
    }
    
    if (!groupData.name || groupData.name.trim().length === 0) {
        return { valid: false, message: '组名不能为空' };
    }
    
    if (groupData.name.length > 50) {
        return { valid: false, message: '组名不能超过50个字符' };
    }
    
    return { valid: true, message: '验证通过' };
}

/**
 * 生成随机颜色
 * @returns {string} 十六进制颜色值
 */
function generateRandomColor() {
    const colors = [
        '#87CEEB', // 天蓝色
        '#FFB6C1', // 浅粉色
        '#98FB98', // 浅绿色
        '#F0E68C', // 卡其色
        '#DDA0DD', // 梅红色
        '#FFA07A', // 浅鲑鱼色
        '#20B2AA', // 浅海绿色
        '#DDA0DD'  // 李子色
    ];
    
    return colors[Math.floor(Math.random() * colors.length)];
}

/**
 * 防抖函数
 * @param {Function} func - 要防抖的函数
 * @param {number} wait - 等待时间(毫秒)
 * @returns {Function} 防抖后的函数
 */
function debounce(func, wait) {
    let timeout;
    return function executedFunction(...args) {
        const later = () => {
            clearTimeout(timeout);
            func(...args);
        };
        clearTimeout(timeout);
        timeout = setTimeout(later, wait);
    };
}

/**
 * 节流函数
 * @param {Function} func - 要节流的函数
 * @param {number} limit - 限制时间(毫秒)
 * @returns {Function} 节流后的函数
 */
function throttle(func, limit) {
    let inThrottle;
    return function(...args) {
        if (!inThrottle) {
            func.apply(this, args);
            inThrottle = true;
            setTimeout(() => inThrottle = false, limit);
        }
    };
}

/**
 * 显示提示消息
 * @param {string} message - 提示消息
 * @param {string} type - 消息类型: 'success', 'error', 'warning', 'info'
 * @param {number} duration - 显示时长(毫秒)
 */
function showMessage(message, type = 'info', duration = 3000) {
    // 创建消息元素
    const messageEl = document.createElement('div');
    messageEl.className = `message message-${type}`;
    messageEl.textContent = message;
    
    // 设置样式
    Object.assign(messageEl.style, {
        position: 'fixed',
        top: '20px',
        right: '20px',
        padding: '12px 20px',
        borderRadius: '8px',
        color: 'white',
        fontWeight: 'bold',
        zIndex: '10000',
        opacity: '0',
        transform: 'translateX(100%)',
        transition: 'all 0.3s ease'
    });
    
    // 根据类型设置背景色
    const colors = {
        success: '#4CAF50',
        error: '#F44336',
        warning: '#FF9800',
        info: '#2196F3'
    };
    messageEl.style.backgroundColor = colors[type] || colors.info;
    
    // 添加到页面
    document.body.appendChild(messageEl);
    
    // 显示动画
    setTimeout(() => {
        messageEl.style.opacity = '1';
        messageEl.style.transform = 'translateX(0)';
    }, 10);
    
    // 自动隐藏
    setTimeout(() => {
        messageEl.style.opacity = '0';
        messageEl.style.transform = 'translateX(100%)';
        setTimeout(() => {
            if (messageEl.parentNode) {
                messageEl.parentNode.removeChild(messageEl);
            }
        }, 300);
    }, duration);
}

/**
 * 确认对话框
 * @param {string} message - 确认消息
 * @param {string} title - 对话框标题
 * @returns {Promise<boolean>} 用户确认结果
 */
function confirmDialog(message, title = '确认') {
    return new Promise((resolve) => {
        const result = confirm(`${title}\n\n${message}`);
        resolve(result);
    });
}

/**
 * 输入对话框
 * @param {string} message - 提示消息
 * @param {string} defaultValue - 默认值
 * @returns {Promise<string|null>} 用户输入结果
 */
function promptDialog(message, defaultValue = '') {
    return new Promise((resolve) => {
        const result = prompt(message, defaultValue);
        resolve(result);
    });
}

/**
 * 检查浏览器是否支持IndexedDB
 * @returns {boolean} 是否支持IndexedDB
 */
function isIndexedDBSupported() {
    return 'indexedDB' in window;
}

/**
 * 检查浏览器是否支持LocalStorage
 * @returns {boolean} 是否支持LocalStorage
 */
function isLocalStorageSupported() {
    try {
        const test = 'test';
        localStorage.setItem(test, test);
        localStorage.removeItem(test);
        return true;
    } catch (e) {
        return false;
    }
}

/**
 * 获取浏览器信息
 * @returns {Object} 浏览器信息
 */
function getBrowserInfo() {
    const ua = navigator.userAgent;
    const browsers = {
        chrome: /Chrome/.test(ua) && /Google Inc/.test(navigator.vendor),
        firefox: /Firefox/.test(ua),
        safari: /Safari/.test(ua) && /Apple Computer/.test(navigator.vendor),
        edge: /Edg/.test(ua),
        ie: /Trident/.test(ua)
    };
    
    const browser = Object.keys(browsers).find(key => browsers[key]) || 'unknown';
    
    return {
        name: browser,
        version: ua.match(/(?:Chrome|Firefox|Safari|Edg|MSIE)[\/\s](\d+(?:\.\d+)*)/)?.[1] || 'unknown',
        userAgent: ua
    };
}

/**
 * 导出数据为JSON
 * @param {Object} data - 要导出的数据
 * @param {string} filename - 文件名
 */
function exportToJSON(data, filename = 'memory-data.json') {
    const jsonString = JSON.stringify(data, null, 2);
    const blob = new Blob([jsonString], { type: 'application/json' });
    const url = URL.createObjectURL(blob);
    
    const a = document.createElement('a');
    a.href = url;
    a.download = filename;
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    URL.revokeObjectURL(url);
}

/**
 * 从JSON文件导入数据
 * @param {File} file - JSON文件
 * @returns {Promise<Object>} 导入的数据
 */
function importFromJSON(file) {
    return new Promise((resolve, reject) => {
        const reader = new FileReader();
        reader.onload = (e) => {
            try {
                const data = JSON.parse(e.target.result);
                resolve(data);
            } catch (error) {
                reject(new Error('JSON文件格式错误'));
            }
        };
        reader.onerror = () => reject(new Error('文件读取失败'));
        reader.readAsText(file);
    });
}
